/**
 * 系统信息
 * 系统监控模块
 * 负责获取和显示系统信息，包括CPU、内存和磁盘使用情况
 */

const { ipcRenderer } = require('electron');
const config = require('../../main/utils/config').systemMonitor;
const { handleError, ErrorTypes, tryCatch } = require('../../common/error-handler');
const { TimeManagementChannels } = require('../../common/ipc-channels');

// 模块状态
let updateInterval = null;
let isPageActive = true; // 页面活动状态标志

/**
 * 初始化系统监控模块
 */
function initialize() {
    console.log('初始化系统监控模块...');

    // 监听系统信息回复
    setupSystemInfoListener();

    // 立即执行一次更新
    updateSystemInfo();

    // 设置定期更新
    updateInterval = setInterval(updateSystemInfo, config.updateInterval);

    // 添加页面可见性和焦点事件监听
    setupVisibilityListeners();

    // 为刷新按钮添加点击事件
    const refreshBtn = document.getElementById('refresh-btn');
    if (refreshBtn) {
        refreshBtn.addEventListener('click', () => {
            console.log('刷新按钮点击');
            // 添加旋转动画
            refreshBtn.classList.add('rotate-animation');

            // 更新系统信息
            updateSystemInfo();

            // 动画结束后移除类
            setTimeout(() => {
                refreshBtn.classList.remove('rotate-animation');
            }, config.refreshAnimationDuration);
        });
    }

    // 初始化快捷操作按钮-立即关机、重启和睡眠
    setupQuickActions();

    console.log('系统监控模块初始化完成');
}

/**
 * 设置快捷操作按钮事件-立即关机、重启和睡眠
 */
function setupQuickActions() {
    // 立即关机按钮
    const shutdownBtn = document.getElementById('index-shutdown-btn');
    if (shutdownBtn) {
        shutdownBtn.addEventListener('click', () => {
            console.log('立即关机按钮点击-总览');
            if (confirm('确定要立即关闭计算机吗？')) {
                ipcRenderer.send(TimeManagementChannels.IMMEDIATE_SHUTDOWN);
            }
        });
    }

    // 重启按钮
    const restartBtn = document.getElementById('index-restart-btn');
    if (restartBtn) {
        restartBtn.addEventListener('click', () => {
            if (confirm('确定要重启计算机吗？')) {
                ipcRenderer.send(TimeManagementChannels.RESTART_COMPUTER);
            }
        });
    }

    // 睡眠按钮
    const sleepBtn = document.getElementById('index-sleep-btn');
    if (sleepBtn) {
        sleepBtn.addEventListener('click', () => {
            if (confirm('确定要使计算机进入睡眠状态吗？')) {
                ipcRenderer.send(TimeManagementChannels.SLEEP_COMPUTER);
            }
        });
    }
}

/**
 * 更新系统信息
 */
function updateSystemInfo() {
    // 更新上次更新时间
    updateLastUpdateTime();

    // 请求系统信息
    tryCatch(
        () => ipcRenderer.send('get-system-info'),
        {
            errorType: ErrorTypes.SYSTEM,
            context: { action: '请求系统信息' },
            onError: (error) => console.error('获取系统信息失败:', error)
        }
    );

    // 更新快捷卡片
    updateQuickCards();
}

/**
 * 更新页面上次更新时间
 */
function updateLastUpdateTime() {
    const now = new Date();
    const timeString = now.toLocaleString('zh-CN', {
        year: 'numeric',
        month: '2-digit',
        day: '2-digit',
        hour: '2-digit',
        minute: '2-digit',
        second: '2-digit',
        hour12: false
    }).replace(/\//g, '-');

    const lastUpdateTimeElement = document.getElementById('last-update-time');
    if (lastUpdateTimeElement) {
        lastUpdateTimeElement.textContent = timeString;
    }
}

/**
 * 更新快捷卡片
 */
function updateQuickCards() {
    // 实现快捷卡片更新逻辑
    // 这里可以添加更新快捷卡片的代码
}

/**
 * 设置系统信息监听器
 */
function setupSystemInfoListener() {
    ipcRenderer.on('system-info-reply', (event, data) => {
        console.log('设置系统信息监听器...', data);
        if (!data.initSystemInfo) {
            handleError('接收到空的系统信息数据', ErrorTypes.SYSTEM, { event: 'system-info-reply' });
            return;
        }

        tryCatch(
            () => {
                // 更新CPU信息
                updateCpuInfo(data);

                // 更新内存信息
                updateMemoryInfo(data);

                // 更新磁盘信息
                updateDiskInfo(data);

                // 显示内存使用情况
                updateMemoryProcesses(data.topMemoryProcesses);
            },
            {
                errorType: ErrorTypes.APPLICATION,
                context: { action: '更新系统信息显示', data: data },
                onError: (error) => console.error('更新系统信息显示失败:', error)
            }
        );
    });
}

/**
 * 更新CPU信息
 * @param {Object} data - 系统信息数据
 */
function updateCpuInfo(data) {
    // 更新CPU使用率和信息
    const cpuUsage = data.cpuUsage;
    const cpuUsageElement = document.getElementById('cpu-usage');
    if (cpuUsageElement) {
        cpuUsageElement.textContent = cpuUsage;
    }

    // 处理进度条 - 只有在数据为百分比值时才更新进度条
    if (cpuUsage.includes && cpuUsage !== '无' && cpuUsage.includes('%')) {
        updateProgressBar('cpu-progress-bar', parseInt(cpuUsage));
    } else {
        // 如果无法获取数据，将进度条设置为0
        updateProgressBar('cpu-progress-bar', 0);
    }

    // 更新CPU温度和频率
    const cpuTempElement = document.getElementById('cpu-temp');
    const cpuFreqElement = document.getElementById('cpu-freq');

    if (cpuTempElement) {
        cpuTempElement.textContent = data.cpuTemp || '无';//温度
    }

    if (cpuFreqElement) {
        cpuFreqElement.textContent = data.cpuFreq || '无';//频率
    }

    // 更新CPU平台和型号信息
    const cpuPlatformElement = document.getElementById('cpu-platform');
    const cpuModelElement = document.getElementById('cpu-model');

    if (cpuPlatformElement && data.initSystemInfo) {
        cpuPlatformElement.textContent = (data.initSystemInfo.cpuPlatform && data.initSystemInfo.cpuPlatform == 'win32' ? 'Win' : 'Mac') || '无';
    }

    if (cpuModelElement && data.initSystemInfo) {
        cpuModelElement.textContent = data.initSystemInfo.cpuModel || '无';
    }
}

/**
 * 更新内存信息
 * @param {Object} data - 系统信息数据
 */
function updateMemoryInfo(data) {
    // 更新内存使用率和信息
    const memoryUsage = data.memoryUsage;
    const memoryUsageElement = document.getElementById('memory-usage');

    if (memoryUsageElement) {
        memoryUsageElement.textContent = memoryUsage;
    }

    // 更新内存进度条
    if (memoryUsage.includes && memoryUsage !== '无' && memoryUsage.includes('%')) {
        updateProgressBar('memory-progress-bar', parseInt(memoryUsage));
    } else {
        updateProgressBar('memory-progress-bar', 0);
    }

    // 更新内存详细信息
    const memoryUsedElement = document.getElementById('memory-used');
    const appMemoryElement = document.getElementById('app-memory');
    const appUptimeElement = document.getElementById('app-uptime');


    if (data.memoryDetails) {
        if (memoryUsedElement) {
            memoryUsedElement.textContent = data.memoryDetails.used || '无';
        }

        if (appMemoryElement) {
            appMemoryElement.textContent = data.memoryDetails.appUsage || '无';
        }
        if (appUptimeElement) {
            appUptimeElement.textContent = data.uptime || '无';
        }
    } else {
        if (memoryUsedElement) {
            memoryUsedElement.textContent = '无';
        }

        if (appMemoryElement) {
            appMemoryElement.textContent = '无';
        }
        if (appUptimeElement) {
            appUptimeElement.textContent = '无';
        }
    }
}

/**
 * 更新磁盘信息
 * @param {Object} data - 系统信息数据
 */
function updateDiskInfo(data) {
    // 更新磁盘使用率和信息
    const diskUsage = data.diskUsage;
    const diskUsageElement = document.getElementById('disk-usage');

    if (diskUsageElement) {
        diskUsageElement.textContent = diskUsage;
    }

    // 更新磁盘进度条
    if (diskUsage.includes && diskUsage !== '无' && diskUsage.includes('%')) {
        updateProgressBar('disk-progress-bar', parseInt(diskUsage));
    } else {
        updateProgressBar('disk-progress-bar', 0);
    }

    // 更新磁盘详细信息
    const diskUsedElement = document.getElementById('disk-used');
    const diskAvailableElement = document.getElementById('disk-available');
    const diskTypeElement = document.getElementById('disk-type');
    const diskModelElement = document.getElementById('disk-model');

    if (data.diskDetails) {
        if (diskUsedElement) {
            diskUsedElement.textContent = data.diskDetails.used || '无';
        }

        if (diskAvailableElement) {
            diskAvailableElement.textContent = data.diskDetails.available || '无';
        }

        if (diskTypeElement) {
            diskTypeElement.textContent = data.diskDetails.type || '未知';
        }

        if (diskModelElement) {
            diskModelElement.textContent = data.diskDetails.model || '未知';

            // 如果存在物理磁盘数量信息，附加到硬盘信息后
            if (data.diskDetails.physical) {
                diskModelElement.textContent += ` (${data.diskDetails.physical})`;
            }
        }
    } else {
        if (diskUsedElement) {
            diskUsedElement.textContent = '无';
        }

        if (diskAvailableElement) {
            diskAvailableElement.textContent = '无';
        }

        if (diskTypeElement) {
            diskTypeElement.textContent = '无';
        }

        if (diskModelElement) {
            diskModelElement.textContent = '无';
        }
    }
}

/**
 * 更新内存进程列表
 * @param {Array} processes - 内存占用最高的进程列表
 */
function updateMemoryProcesses(processes) {
    if (!processes || processes.length === 0) return;

    for (let i = 0; i < Math.min(processes.length, 4); i++) {
        const process = processes[i];
        const nameElement = document.getElementById(`memory${i}-name`);
        const valueElement = document.getElementById(`memory${i}-value`);

        if (nameElement && valueElement) {
            nameElement.textContent = process.name;
            valueElement.textContent = process.memoryUsage;
        }
    }
}

/**
 * 更新进度条
 * @param {string} elementId - 进度条元素ID
 * @param {number} percentage - 百分比值
 */
function updateProgressBar(elementId, percentage) {
    const progressBar = document.getElementById(elementId);
    if (progressBar) {
        // 确保百分比在有效范围内
        const validPercentage = Math.max(0, Math.min(100, percentage));
        progressBar.style.width = `${validPercentage}%`;

        // 根据百分比改变颜色
        if (validPercentage === 0) {
            // 无数据或为0时显示灰色
            progressBar.style.backgroundColor = config.progressBarColors.none;
        } else if (validPercentage > config.loadThresholds.high) {
            progressBar.style.backgroundColor = config.progressBarColors.high; // 高负载时红色
        } else if (validPercentage > config.loadThresholds.medium) {
            progressBar.style.backgroundColor = config.progressBarColors.medium; // 中等负载时橙色
        } else {
            // 低负载时绿色
            progressBar.style.backgroundColor = config.progressBarColors.low;
        }
    }
}

/**
 * 设置页面可见性和焦点事件监听器
 */
function setupVisibilityListeners() {
    // 页面可见性变化事件 - 使用命名函数以便于后续移除
    document.addEventListener('visibilitychange', handleVisibilityChange);

    // 窗口失去焦点事件
    window.addEventListener('blur', handleBlur);

    // 窗口获得焦点事件
    window.addEventListener('focus', handleFocus);
}

/**
 * 处理页面可见性变化
 */
function handleVisibilityChange() {
    if (document.hidden) {
        // 页面不可见时暂停更新
        pauseUpdates();
    } else {
        // 页面可见时恢复更新
        resumeUpdates();
    }
}

/**
 * 处理窗口失去焦点
 */
function handleBlur() {
    pauseUpdates();
}

/**
 * 处理窗口获得焦点
 */
function handleFocus() {
    resumeUpdates();
}

/**
 * 暂停系统信息更新
 */
function pauseUpdates() {
    console.log('系统监控模块：页面失去焦点，暂停更新');
    isPageActive = false;

    // 清除更新间隔
    if (updateInterval) {
        clearInterval(updateInterval);
        updateInterval = null;
    }
}

/**
 * 恢复系统信息更新
 */
function resumeUpdates() {
    console.log('系统监控模块：页面获得焦点，恢复更新');
    isPageActive = true;

    // 立即执行一次更新
    updateSystemInfo();

    // 重新设置定期更新
    if (!updateInterval) {
        updateInterval = setInterval(updateSystemInfo, config.updateInterval);
    }
}

/**
 * 清理资源
 */
function cleanup() {
    // 清除更新间隔
    if (updateInterval) {
        clearInterval(updateInterval);
        updateInterval = null;
    }

    // 移除事件监听器
    ipcRenderer.removeAllListeners('system-info-reply');

    // 移除页面可见性和焦点事件监听器
    document.removeEventListener('visibilitychange', handleVisibilityChange);
    window.removeEventListener('blur', handleBlur);
    window.removeEventListener('focus', handleFocus);
}

// 导出模块
module.exports = {
    initialize,
    updateSystemInfo,
    cleanup
};